* **** BEGIN LICENSE BLOCK *****

* Version: CPL 1.0/GPL 2.0/LGPL 2.1

*

* The contents of this file are subject to the Common Public

* License Version 1.0 (the "License"); you may not use this file

* except in compliance with the License. You may obtain a copy of

* the License at http://www.eclipse.org/legal/cpl-v10.html

*

* Software distributed under the License is distributed on an "AS

* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

* implied. See the License for the specific language governing

* rights and limitations under the License.

*

* Copyright (C) 2009-2010 Yoko Harada <yokolet@gmail.com>

*

* Alternatively, the contents of this file may be used under the terms of

* either of the GNU General Public License Version 2 or later (the "GPL"),

* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

* in which case the provisions of the GPL or the LGPL are applicable instead

* of those above. If you wish to allow use of your version of this file only

* under the terms of either the GPL or the LGPL, and not to allow others to

* use your version of this file under the terms of the CPL, indicate your

* decision by deleting the provisions above and replace them with the notice

* and other provisions required by the GPL or the LGPL. If you do not delete

* the provisions above, a recipient may use your version of this file under

* the terms of any one of the CPL, the GPL or the LGPL.

* **** END LICENSE BLOCK *****

*/

*

* @author yoko

*/

    static Logger logger0 = Logger.getLogger(MultipleScriptsRunner.class.getName());

    static Logger logger1 = Logger.getLogger(MultipleScriptsRunner.class.getName());

    static OutputStream outStream = null;

    PrintStream pstream = null;

    FileWriter writer = null;

    String basedir = System.getProperty("user.dir");

    public ScriptingContainerTest() {

    }

    @BeforeClass

    public static void setUpClass() throws Exception {

    }

    @AfterClass

    public static void tearDownClass() throws Exception {

        outStream.close();

    }

    @Before

    public void setUp() throws FileNotFoundException, IOException {

        outStream = new FileOutputStream(System.getProperty("user.dir") + "/build/test-results/run-junit-embed.log", true);

        Handler handler = new StreamHandler(outStream, new SimpleFormatter());

        logger0.addHandler(handler);

        logger0.setUseParentHandlers(false);

        logger0.setLevel(Level.INFO);

        logger1.setUseParentHandlers(false);

        logger1.addHandler(new ConsoleHandler());

        logger1.setLevel(Level.WARNING);

        pstream = new PrintStream(outStream, true);

        writer = new FileWriter(basedir + "/build/test-results/run-junit-embed.txt", true);

    }

    @After

    public void tearDown() throws IOException {

        pstream.close();

        writer.close();

    }

    /**

     * Test of getProperty method, of class ScriptingContainer.

     */

    @Test

    public void testGetProperty() {

        logger1.info("getProperty");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        String key = "language.extension";

        String[] extensions = {"rb"};

        String[] result = instance.getProperty(key);

        assertArrayEquals(key, extensions, result);

        key = "language.name";

        String[] names = {"ruby"};

        result = instance.getProperty(key);

        assertArrayEquals(key, names, result);

        instance = null;

    }

    /**

     * Test of getSupportedRubyVersion method, of class ScriptingContainer.

     */

    @Test

    public void testGetSupportedRubyVersion() {

        logger1.info("getSupportedRubyVersion");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        String expResult = "jruby " + Constants.VERSION;

        String result = instance.getSupportedRubyVersion();

        assertTrue(result.startsWith(expResult));

        instance = null;

    }

    /**

     * Test of getProvider method, of class ScriptingContainer.

     */

    @Test

    public void testGetProvider() {

        logger1.info("getProvider");

        ScriptingContainer instance = new ScriptingContainer();

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        LocalContextProvider result = instance.getProvider();

        assertTrue(result instanceof SingletonLocalContextProvider);

        instance = null;

        instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        result = instance.getProvider();

        assertTrue(result instanceof ThreadSafeLocalContextProvider);

        instance = null;

        instance = new ScriptingContainer(LocalContextScope.SINGLETHREAD);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        result = instance.getProvider();

        assertTrue(result instanceof SingleThreadLocalContextProvider);

        instance = null;

        instance = new ScriptingContainer(LocalContextScope.SINGLETON);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        result = instance.getProvider();

        assertTrue(result instanceof SingletonLocalContextProvider);

        instance = null;

       

        instance = new ScriptingContainer(LocalContextScope.CONCURRENT);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        result = instance.getProvider();

        assertTrue(result instanceof ConcurrentLocalContextProvider);

        instance = null;

    }

    /**

     * Test of getRuntime method, of class ScriptingContainer.

     */

    @Test

    public void testGetRuntime() {

        logger1.info("getRuntime");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        Ruby runtime  = JavaEmbedUtils.initialize(new ArrayList());

        Ruby result = instance.getProvider().getRuntime();

        Class expClazz = runtime.getClass();

        Class resultClazz = result.getClass();

        assertEquals(expClazz, resultClazz);

        instance = null;

    }

    /**

     * Test of getVarMap method, of class ScriptingContainer.

     */

    @Test

    public void testGetVarMap() {

        logger1.info("getVarMap");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        BiVariableMap result = instance.getVarMap();

        result.put("@name", "camellia");

        assertEquals("camellia", instance.getVarMap().get("@name"));

        result.put("COLOR", "red");

        assertEquals("red", instance.getVarMap().get("COLOR"));

        // class variable injection does not work

        //result.put("@@season", "spring");

        //assertEquals("spring", instance.getVarMap().get("@@season"));

        result.put("$category", "flower");

        assertEquals("flower", instance.getVarMap().get("$category"));

        result.put("@name", "maple");

        assertEquals("maple", instance.getVarMap().get("@name"));

        result.put("COLOR", "orangered");

        assertEquals("orangered", instance.getVarMap().get("COLOR"));

        result.put("$category", "tree");

        assertEquals("tree", instance.getVarMap().get("$category"));

        result.put("parameter", 1.2345);

        assertEquals(1.2345, instance.getVarMap().get("parameter"));

        result.put("@coefficient", 4);

        assertEquals(4, instance.getVarMap().get("@coefficient"));

       

        result.clear();

        instance = null;

    }

    /**

     * Test of getAttributeMap method, of class ScriptingContainer.

     */

    @Test

    public void testGetAttributeMap() {

        logger1.info("getAttributeMap");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

       

        Map result = instance.getAttributeMap();

        Object obj = result.get(AttributeName.READER);

        assertEquals(obj.getClass(), java.io.InputStreamReader.class);

        obj = result.get(AttributeName.WRITER);

        assertEquals(obj.getClass(), java.io.PrintWriter.class);

        obj = result.get(AttributeName.ERROR_WRITER);

        assertEquals(obj.getClass(), java.io.PrintWriter.class);

       

        result.put(AttributeName.BASE_DIR, "/usr/local/lib");

        assertEquals("/usr/local/lib", result.get(AttributeName.BASE_DIR));

        result.put(AttributeName.LINENUMBER, 5);

        assertEquals(5, result.get(AttributeName.LINENUMBER));

        result.put("むなしいきもち", "虚");

        assertEquals("虚", result.get("むなしいきもち"));

        result.clear();

        instance = null;

    }

    /**

     * Test of getAttribute method, of class ScriptingContainer.

     */

    //@Test

    public void testGetAttribute() {

        logger1.info("getAttribute");

        Object key = null;

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        Object expResult = null;

        Object result = instance.getAttribute(key);

        assertEquals(expResult, result);

        // TODO review the generated test code and remove the default call to fail.

        fail("The test case is a prototype.");

    }

    /**

     * Test of setAttribute method, of class ScriptingContainer.

     */

    //@Test

    public void testSetAttribute() {

        logger1.info("setAttribute");

        Object key = null;

        Object value = null;

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        Object expResult = null;

        Object result = instance.setAttribute(key, value);

        assertEquals(expResult, result);

        // TODO review the generated test code and remove the default call to fail.

        fail("The test case is a prototype.");

    }

    /**

     * Test of get method, of class ScriptingContainer.

     */

    @Test

    public void testGet() {

        logger1.info("get");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        String key = null;

        try {

            instance.get(key);

        } catch (NullPointerException e) {

            assertEquals("key is null", e.getMessage());

        }

        key = "";

        try {

            instance.get(key);

        } catch (IllegalArgumentException e) {

            assertEquals("key is empty", e.getMessage());

        }

        key = "a";

        Object expResult = null;

        Object result = instance.get(key);

        assertEquals(expResult, result);

       

        instance.put("@name", "camellia");

        assertEquals("camellia", instance.get("@name"));

        instance.put("COLOR", "red");

        assertEquals("red", instance.get("COLOR"));

        // class variables doesn't work

        //varMap.put("@@season", "spring");

        //assertEquals("spring", instance.get("@@season"));

        instance.put("$category", "flower");

        assertEquals("flower", instance.get("$category"));

        // Bug. Can't retrieve instance variables from Ruby.

        instance.runScriptlet("@eular = 2.718281828");

        assertEquals(2.718281828, instance.get("@eular"));

        instance.runScriptlet("@name = \"holly\"");

        assertEquals("holly", instance.get("@name"));

        instance.runScriptlet("$category = \"bush\"");

        assertEquals("bush", instance.get("$category"));

        instance.getVarMap().clear();

        instance = null;

        instance = new ScriptingContainer(LocalContextScope.THREADSAFE, LocalVariableBehavior.PERSISTENT);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        instance.runScriptlet("ivalue = 200000");

        assertEquals(200000L, instance.get("ivalue"));

       

        instance.getVarMap().clear();

        instance = null;

    }

    /**

     * Test of put method, of class ScriptingContainer.

     */

    @Test

    public void testPut() {

        logger1.info("put");

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        String key = null;

        try {

            instance.get(key);

        } catch (NullPointerException e) {

            assertEquals("key is null", e.getMessage());

        }

        key = "";

        try {

            instance.get(key);

        } catch (IllegalArgumentException e) {

            assertEquals("key is empty", e.getMessage());

        }

        key = "a";

        Object value = null;

        Object expResult = null;

        Object result = instance.put(key, value);

        Object newValue = "xyz";

        result = instance.put(key, newValue);

        assertEquals(expResult, result);

        expResult = "xyz";

        assertEquals(expResult, instance.get(key));

        StringWriter sw = new StringWriter();

        instance.setWriter(sw);

        instance.put("x", 144.0);

        instance.runScriptlet("puts Math.sqrt(x)");

        assertEquals("12.0", sw.toString().trim());

        sw = new StringWriter();

        instance.setWriter(sw);

        instance.put("@x", 256.0);

        instance.runScriptlet("puts Math.sqrt(@x)");

        assertEquals("16.0", sw.toString().trim());

        sw = new StringWriter();

        instance.setWriter(sw);

        instance.put("$x", 9.0);

        instance.runScriptlet("puts Math.sqrt($x)");

        assertEquals("3.0", sw.toString().trim());

        sw = new StringWriter();

        instance.setWriter(sw);

        instance.put("KMTOMI", 0.621);

        instance.runScriptlet("puts \"1 km is #{KMTOMI} miles.\"");

        assertEquals("1 km is 0.621 miles.", sw.toString().trim());

        instance.getVarMap().clear();

        instance = null;

    }

    /**

     * Test of parse method, of class ScriptingContainer.

     */

    @Test

    public void testParse_String_intArr() {

        logger1.info("parse");

        String script = null;

        int[] lines = null;

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        EmbedEvalUnit expResult = null;

        EmbedEvalUnit result = instance.parse(script, lines);

        assertEquals(expResult, result);

        script = "";

        Ruby runtime = JavaEmbedUtils.initialize(new ArrayList());

        Node node = runtime.parseEval(script, "<script>", null, 0);

        IRubyObject expRet = runtime.runInterpreter(node);

        result = instance.parse(script);

        IRubyObject ret = result.run();

        assertEquals(expRet.toJava(String.class), ret.toJava(String.class));

        // Maybe bug. This returns RubyNil, but it should be ""

        //assertEquals("", ret.toJava(String.class));

        script = "def say_something()" +

                   "\"はろ〜、わぁ〜るど！\"\n" +

                 "end\n" +

                 "say_something";

        expRet = runtime.runInterpreter(runtime.parseEval(script, "<script>", null, 0));

        ret = instance.parse(script).run();

        assertEquals(expRet.toJava(String.class), ret.toJava(String.class));

        //sharing variables

        instance.put("what", "Trick or Treat.");

        script = "\"Did you say, #{what}?\"";

        result = instance.parse(script);

        ret = result.run();

        assertEquals("Did you say, Trick or Treat.?", ret.toJava(String.class));

        // line number test

        script = "puts \"Hello World!!!\"\nputs \"Have a nice day!";

        StringWriter sw = new StringWriter();

        instance.setErrorWriter(sw);

        try {

            instance.parse(script, 1);

        } catch (Exception e) {

            assertTrue(sw.toString().contains("<script>:3:"));

        }

        instance.getVarMap().clear();

        instance = null;

    }

    /**

     * Test of parse method, of class ScriptingContainer.

     */

    @Test

    public void testParse_3args_1() throws FileNotFoundException {

        logger1.info("parse(reader, filename, lines)");

        Reader reader = null;

        String filename = "";

        int[] lines = null;

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        EmbedEvalUnit expResult = null;

        EmbedEvalUnit result = instance.parse(reader, filename, lines);

        assertEquals(expResult, result);

        filename = basedir + "/test/org/jruby/embed/ruby/iteration.rb";

        reader = new FileReader(filename);

        instance.put("@t", 2);

        result = instance.parse(reader, filename);

        IRubyObject ret = result.run();

        String expStringResult =

            "Trick or Treat!\nTrick or Treat!\n\nHmmm...I'd like trick.";

        assertEquals(expStringResult, ret.toJava(String.class));

        // line number test

        filename = basedir + "/test/org/jruby/embed/ruby/raises_parse_error.rb";

        reader = new FileReader(filename);

        StringWriter sw = new StringWriter();

        instance.setErrorWriter(sw);

        try {

            instance.parse(reader, filename, 2);

        } catch (Exception e) {

            logger1.info(sw.toString());

            assertTrue(sw.toString().contains(filename + ":7:"));

        }

        instance.getVarMap().clear();

        instance = null;

    }

    /**

     * Test of parse method, of class ScriptingContainer.

     */

    @Test

    public void testParse_3args_2() {

        logger1.info("parse(type, filename, lines)");

        PathType type = null;

        String filename = "";

        int[] lines = null;

        String[] paths = {basedir + "/lib", basedir + "/lib/ruby/1.8"};

        ScriptingContainer instance = new ScriptingContainer(LocalContextScope.THREADSAFE);

        instance.setLoadPaths(Arrays.asList(paths));

        instance.setError(pstream);

        instance.setOutput(pstream);

        instance.setWriter(writer);

        instance.setErrorWriter(writer);

        EmbedEvalUnit result;

       

        try {

            result = instance.parse(type, filename, lines);

        } catch (Throwable t) {

            assertTrue(t.getCause() instanceof FileNotFoundException);

            t.printStackTrace(new PrintStream(outStream));

        }

        filename = basedir + "/test/org/jruby/embed/ruby/next_year.rb";

        result = instance.parse(PathType.ABSOLUTE, filename);

        IRubyObject ret = result.run();

        assertEquals(getNextYear(), ret.toJava(Integer.class));

        StringWriter sw = new StringWriter();

        instance.setWriter(sw);

        String[] planets = {"Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"};

        instance.put("@list", Arrays.asList(planets));

        filename = "/test/org/jruby/embed/ruby/list_printer.rb";

        result = instance.parse(PathType.RELATIVE, filename);

        ret = result.run();

        String expResult = "Mercury >> Venus >> Earth >> Mars >> Jupiter >> Saturn >> Uranus >> Neptune: 8 in total";

        assertEquals(expResult, sw.toString().trim());

        sw = new StringWriter();

        instance.setWriter(sw);

        instance.setAttribute(AttributeName.UNICODE_ESCAPE, true);